home *** CD-ROM | disk | FTP | other *** search
/ CD ROM Paradise Collection 4 / CD ROM Paradise Collection 4 1995 Nov.iso / clang / gnumake.zip / PATCHES.OS2 < prev    next >
Text File  |  1994-06-07  |  30KB  |  1,129 lines
  1. Only in new: README.OS2
  2. Only in new: patches.os2
  3. Only in new: Makefile.os2
  4. Only in new/glob: Makefile.os2
  5. Only in new: make.def
  6. Only in new: config.h
  7. diff -cbr orig/function.c new/function.c
  8. *** orig/function.c    Fri Mar 04 07:36:26 1994
  9. --- new/function.c    Tue Jun 07 17:39:16 1994
  10. ***************
  11. *** 377,388 ****
  12. --- 377,394 ----
  13.           break;
  14.         }
  15.   
  16. + #ifndef __EMX__
  17.       pid = vfork ();
  18.       if (pid < 0)
  19.         perror_with_name (error_prefix, "fork");
  20.       else if (pid == 0)
  21.         child_execute_job (0, pipedes[1], argv, envp);
  22.       else
  23. + #else
  24. +       if((pid = child_execute_job(0,pipedes[1], argv, environ)) < 0) {
  25. +         perror_with_name (error_prefix, "spawn");
  26. +       }
  27. + #endif
  28.         {
  29.           /* We are the parent.  */
  30.   
  31. diff -cbr orig/job.c new/job.c
  32. *** orig/job.c    Tue May 10 22:00:40 1994
  33. --- new/job.c    Tue Jun 07 18:40:28 1994
  34. ***************
  35. *** 21,32 ****
  36.   #include "job.h"
  37.   #include "file.h"
  38.   #include "variable.h"
  39.   
  40.   /* Default path to search for executables.  */
  41.   static char default_path[] = ":/bin:/usr/bin";
  42. - 
  43.   /* Default shell to use.  */
  44.   char default_shell[] = "/bin/sh";
  45.   
  46.   /* If NGROUPS_MAX == 0 then try other methods for finding a real value.  */
  47.   #if defined (NGROUPS_MAX) && NGROUPS_MAX == 0
  48. --- 21,43 ----
  49.   #include "job.h"
  50.   #include "file.h"
  51.   #include "variable.h"
  52. + #ifdef __EMX__
  53. + #include <process.h>
  54. + #endif
  55. + #ifdef HAVE_FCNTL_H
  56. + #include <fcntl.h>
  57. + #endif
  58.   
  59. + #ifndef __EMX__
  60.   /* Default path to search for executables.  */
  61.   static char default_path[] = ":/bin:/usr/bin";
  62.   /* Default shell to use.  */
  63.   char default_shell[] = "/bin/sh";
  64. + #else
  65. + /* I don't know what would pass for reasonable under OS/2 */
  66. + static char default_path[] = "\\os2;\\bin;\\usr\\bin";
  67. + char default_shell[] = "\\os2\\cmd.exe";
  68. + #endif
  69.   
  70.   /* If NGROUPS_MAX == 0 then try other methods for finding a real value.  */
  71.   #if defined (NGROUPS_MAX) && NGROUPS_MAX == 0
  72. ***************
  73. *** 650,655 ****
  74. --- 661,667 ----
  75.   #endif
  76.   
  77.         child->remote = 0;
  78. + #ifndef __EMX__
  79.         child->pid = vfork ();
  80.         if (child->pid == 0)
  81.       {
  82. ***************
  83. *** 665,670 ****
  84. --- 677,696 ----
  85.         perror_with_name ("vfork", "");
  86.         goto error;
  87.       }
  88. + #else
  89. +       child->pid = child_execute_job(child->good_stdin ? 0 : bad_stdin, 1,
  90. +                      argv, child->environment);
  91. +       /* if we've opened a pipe for the stdin of this command,
  92. +        * close it after the spawn, since we don't exec and let
  93. +        * the child handles croak of their own free will.
  94. +        */
  95. +       if(!child->good_stdin)
  96. +     close(bad_stdin);
  97. +       if(child->pid < 0) {
  98. +     unblock_sigs();
  99. +     goto error;
  100. +       }
  101. + #endif
  102.       }
  103.   
  104.     /* We are the parent side.  Set the state to
  105. ***************
  106. *** 979,994 ****
  107. --- 1005,1030 ----
  108.      STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is
  109.      the environment of the new program.  This function does not return.  */
  110.   
  111. + #ifndef __EMX__
  112.   void
  113. + #else
  114. + int
  115. + #endif
  116.   child_execute_job (stdin_fd, stdout_fd, argv, envp)
  117.        int stdin_fd, stdout_fd;
  118.        char **argv, **envp;
  119.   {
  120. + #ifdef __EMX__
  121. +   int oldstdin = dup(0), oldstdout = dup(1), rval;
  122. +   fcntl(oldstdin, F_SETFD, 1);
  123. +   fcntl(oldstdout, F_SETFD, 1);
  124. + #endif
  125.     if (stdin_fd != 0)
  126.       (void) dup2 (stdin_fd, 0);
  127.     if (stdout_fd != 1)
  128.       (void) dup2 (stdout_fd, 1);
  129.   
  130. + #ifndef __EMX__
  131.     /* Free up file descriptors.  */
  132.     {
  133.       register int d;
  134. ***************
  135. *** 996,1006 ****
  136.       for (d = 3; d < max; ++d)
  137.         (void) close (d);
  138.     }
  139. - 
  140.     /* Run the command.  */
  141.     exec_command (argv, envp);
  142.   }
  143.   
  144.   /* Search PATH for FILE.
  145.      If successful, store the full pathname in PROGRAM and return 1.
  146.      If not sucessful, return zero.  */
  147. --- 1032,1081 ----
  148.       for (d = 3; d < max; ++d)
  149.         (void) close (d);
  150.     }
  151.     /* Run the command.  */
  152.     exec_command (argv, envp);
  153. + #else
  154. +   rval = exec_command (argv, envp);
  155. +   dup2(oldstdin,0); dup2(oldstdout,1);
  156. +   close(oldstdin); close(oldstdout);
  157. +   return rval;
  158. + #endif
  159.   }
  160.   
  161. + /* Return one if the file is an internal SHELL command
  162. +    Return zero otherwise
  163. +  */
  164. + static int
  165. + is_shell_command(str)
  166. +      char *str;
  167. + {    
  168. +   register int j;
  169. + #ifndef __EMX__    
  170. +   static char *sh_cmds[] = { "cd", "eval", "exec", "exit", "login",
  171. +                              "logout", "set", "umask", "wait", "while", "for",
  172. +                              "case", "if", ":", ".", "break", "continue",
  173. +                              "export", "read", "readonly", "shift", "times",
  174. +                              "trap", "switch", 0 };
  175. +   for (j = 0; sh_cmds[j] != 0; ++j)
  176. +     if (streq (sh_cmds[j], str))
  177. +       return 1;
  178. + #else
  179. +   static char *sh_cmds[] = {
  180. +     "call","cd","chcp","chdir","cls","copy","date","del","detach",
  181. +     "dir","do","echo","else","endlocal","erase","errorlevel","exist",
  182. +     "exit","extproc","for","goto","if","in","keys","md","mkdir","move",
  183. +     "not","path","pause","prompt","rd","rem","ren","rename","rmdir",
  184. +     "set","setlocal","shift","start","time","type","ver","verify","vol",0
  185. +   };
  186. +   /* Shell command can be either upper or lower case */
  187. +   for (j = 0; sh_cmds[j] != 0; ++j)
  188. +     if(stricmp(sh_cmds[j], str) == 0)
  189. +       return 1;
  190. + #endif          
  191. +   return 0;
  192. + }
  193. + 
  194. + 
  195.   /* Search PATH for FILE.
  196.      If successful, store the full pathname in PROGRAM and return 1.
  197.      If not sucessful, return zero.  */
  198. ***************
  199. *** 1012,1018 ****
  200. --- 1087,1097 ----
  201.     if (path == 0 || path[0] == '\0')
  202.       path = default_path;
  203.   
  204. + #ifndef __EMX__
  205.     if (index (file, '/') != 0)
  206. + #else
  207. +   if (index(file,'/') != 0 || index (file, '\\') != 0 || file[1] == ':')
  208. + #endif
  209.       {
  210.         strcpy (program, file);
  211.         return 1;
  212. ***************
  213. *** 1043,1055 ****
  214. --- 1122,1148 ----
  215.   #endif    /* Have getgroups.  */
  216.   
  217.         len = strlen (file) + 1;
  218. + #ifdef __EMX__
  219. +       /* the standard OS/2 behavior is to look in CWD */
  220. +       {
  221. +     struct stat st;
  222. +     if(stat(file,&st) == 0) {
  223. +       strcpy(program,file);
  224. +       return 1;
  225. +     }
  226. +       }
  227. + #endif
  228.         do
  229.       {
  230.         struct stat st;
  231.         int perm;
  232.         char *p;
  233.   
  234. + #ifndef __EMX__
  235.         p = index (path, ':');
  236. + #else
  237. +       p = index (path, ';');
  238. + #endif
  239.         if (p == 0)
  240.           p = path + strlen (path);
  241.   
  242. ***************
  243. *** 1094,1110 ****
  244.     return 0;
  245.   }
  246.   
  247.   /* Replace the current process with one running the command in ARGV,
  248.      with environment ENVP.  This function does not return.  */
  249.   
  250.   void
  251.   exec_command (argv, envp)
  252.        char **argv, **envp;
  253.   {
  254.     char *shell, *path;
  255.     PATH_VAR (program);
  256.     register char **ep;
  257. ! 
  258.     shell = path = 0;
  259.     for (ep = envp; *ep != 0; ++ep)
  260.       {
  261. --- 1187,1323 ----
  262.     return 0;
  263.   }
  264.   
  265. + #ifdef __EMX__
  266. +  
  267. + /* Using something DOSISH all executables have extentions 
  268. + /* So append these and then search for them in the path.
  269. +  */
  270. + static int
  271. + emx_search_path (file, path, program)
  272. +      char *file, *path, *program;
  273. + {
  274. +   static char *suffixes[] = { ".exe", ".com", ".cmd", ".bat", NULL };
  275. +   char *dot, tmp[PATH_MAX]; 
  276. +   int i,namelen;
  277. + 
  278. +   if (search_path(file,path,program)==1)
  279. +     return 1;
  280. + 
  281. +   if ((namelen = strlen(file)) < 4 || file[namelen-4] != '.') {
  282. +     for (i = 0; suffixes[i]; i++) {
  283. +       strcpy(tmp,file);
  284. +       strcat(tmp,suffixes[i]);
  285. +       if (search_path(tmp,path,program) == 1) {
  286. +     return 1;
  287. +       }
  288. +     }
  289. +   }
  290. + 
  291. +   return 0;
  292. + }
  293. + 
  294. + /* Have people call emx_search_path in the remainder of the program.
  295. + /* This will mimic regular behaviour.
  296. +  */
  297. + #define search_path emx_search_path 
  298. + 
  299. + /* Return zero if the file is not a script.
  300. +    Return one if it is a script.
  301. +  */
  302. + static int
  303. + is_script(file)
  304. +     char *file;
  305. + {
  306. +     static char *script_suffixes[] = { ".cmd", ".bat", NULL };
  307. +     int i, namelen;
  308. +     char *tmp;
  309. +     struct stat st;
  310. +     PATH_VAR(prog);
  311. +     
  312. +     /* setup a temporary file name, which is lower case. */
  313. +     namelen = strlen(file);
  314. +     tmp = malloc(namelen+5);
  315. +     strcpy(tmp,file); 
  316. +     strlwr(tmp);
  317. +     for (i=0; script_suffixes[i]; i++) {
  318. +         /* does it contain the extension */
  319. +         if (strstr(file,script_suffixes[i])!=NULL) {
  320. +             /* the user thinks it should be a script */
  321. +             return 1;   
  322. +         } else {
  323. +             if (file[namelen-4] == '.') {
  324. +                 /* it did have an extension so it can't be a script */
  325. +                 return 0;
  326. +             }  else {
  327. +                 /* append the extension and see if the file exists. */
  328. +                 tmp[namelen] = '\0';
  329. +                 strcat(tmp,script_suffixes[i]);
  330. +                 if(search_path (tmp, getenv("PATH"), prog)==1)
  331. +                      return 1;
  332. +             }
  333. +         }
  334. +     }
  335. +     /* should not be a script here */
  336. +     return 0;
  337. + }
  338. + 
  339. + char *
  340. + os2_shell(for_cmd)
  341. +   int for_cmd;
  342. + {
  343. +   char *make_shell,*comspec,*os2_shell;
  344. + 
  345. +   make_shell = getenv("MAKE_SHELL");
  346. +   comspec = getenv("COMSPEC");
  347. +   os2_shell = getenv("OS2_SHELL");
  348. + 
  349. +   if(make_shell != NULL && !for_cmd)
  350. +     return make_shell;
  351. +   else if(comspec != NULL)
  352. +     return comspec;
  353. +   else if(os2_shell != NULL)
  354. +     return os2_shell;
  355. +   else
  356. +     return default_shell;
  357. + }
  358. + 
  359. + int
  360. + is_cmd_exe(shell)
  361. +   char *shell;
  362. + {
  363. +   char basename[64];
  364. +   _splitpath(shell, NULL, NULL, basename, NULL);
  365. +   return (stricmp(basename,"4os2") == 0 || stricmp(basename,"cmd") == 0) ||
  366. +          (stricmp(basename,"4dos") == 0 || stricmp(basename,"command") == 0);
  367. + }
  368. + 
  369. + #else
  370. + 
  371. + static int
  372. + is_script(file)
  373. +      char *file;
  374. + {    return 0;
  375. + }
  376. + 
  377. + #endif
  378. + 
  379.   /* Replace the current process with one running the command in ARGV,
  380.      with environment ENVP.  This function does not return.  */
  381.   
  382. + #ifndef __EMX__
  383.   void
  384. + #else
  385. + int
  386. + #endif
  387.   exec_command (argv, envp)
  388.        char **argv, **envp;
  389.   {
  390.     char *shell, *path;
  391.     PATH_VAR (program);
  392.     register char **ep;
  393. ! #ifdef __EMX__
  394. !   int pid = -1;
  395. ! #endif
  396.     shell = path = 0;
  397.     for (ep = envp; *ep != 0; ++ep)
  398.       {
  399. ***************
  400. *** 1115,1120 ****
  401. --- 1328,1337 ----
  402.         else if (path != 0 && shell != 0)
  403.       break;
  404.       }
  405. + #ifdef __EMX__
  406. +   if (shell == 0)
  407. +     shell = os2_shell(0);
  408. + #endif
  409.   
  410.     /* Be the user, permanently.  */
  411.     child_access ();
  412. ***************
  413. *** 1123,1137 ****
  414.       error ("%s: Command not found", argv[0]);
  415.     else
  416.       {
  417.         /* Run the program.  */
  418.         execve (program, argv, envp);
  419. - 
  420.         if (errno == ENOEXEC)
  421.       {
  422.         PATH_VAR (shell_program);
  423.         char *shell_path;
  424.         if (shell == 0)
  425.           shell_path = default_shell;
  426.         else
  427.           {
  428.             if (search_path (shell, path, shell_program))
  429. --- 1340,1364 ----
  430.       error ("%s: Command not found", argv[0]);
  431.     else
  432.       {
  433. + #ifndef __EMX__
  434.         /* Run the program.  */
  435.         execve (program, argv, envp);
  436.         if (errno == ENOEXEC)
  437. + #else
  438. +       pid = spawnve(P_NOWAIT,program,
  439. +             (const char * const *)argv,
  440. +             (const char * const *)envp);
  441. +       if(pid == -1)
  442. + #endif      
  443.       {
  444.         PATH_VAR (shell_program);
  445.         char *shell_path;
  446.         if (shell == 0)
  447. + #ifdef __EMX__
  448.           shell_path = default_shell;
  449. + #else
  450. +         shell_path = os2_shell(1);
  451. + #endif
  452.         else
  453.           {
  454.             if (search_path (shell, path, shell_program))
  455. ***************
  456. *** 1146,1175 ****
  457.         if (shell_path != 0)
  458.           {
  459.             char **new_argv;
  460. !           int argc;
  461.   
  462.             argc = 1;
  463.             while (argv[argc] != 0)
  464.           ++argc;
  465.   
  466.             new_argv = (char **) alloca ((1 + argc + 1) * sizeof (char *));
  467.             new_argv[0] = shell_path;
  468. !           new_argv[1] = program;
  469.             while (argc > 0)
  470.           {
  471. !           new_argv[1 + argc] = argv[argc];
  472.             --argc;
  473.           }
  474.   
  475.             execve (shell_path, new_argv, envp);
  476.             perror_with_name ("execve: ", shell_path);
  477.           }
  478.       }
  479.         else
  480.       perror_with_name ("execve: ", program);
  481.       }
  482. ! 
  483.     _exit (127);
  484.   }
  485.   
  486.   /* Figure out the argument list necessary to run LINE as a command.
  487. --- 1373,1423 ----
  488.         if (shell_path != 0)
  489.           {
  490.             char **new_argv;
  491. !           int argc, arg;
  492.   
  493.             argc = 1;
  494.             while (argv[argc] != 0)
  495.           ++argc;
  496.   
  497. +           arg = 0;
  498. + #ifdef __EMX__
  499. +           new_argv = (char **) alloca ((1 + argc + 2) * sizeof (char *));
  500. +           new_argv[0] = shell_path;
  501. +           new_argv[++arg] = "/c";
  502. + #else
  503.             new_argv = (char **) alloca ((1 + argc + 1) * sizeof (char *));
  504.             new_argv[0] = shell_path;
  505. ! #endif
  506. !           new_argv[++arg] = program;
  507.             while (argc > 0)
  508.           {
  509. !           new_argv[arg + argc] = argv[argc];
  510.             --argc;
  511.           }
  512.   
  513. +           /* Run the program.  */
  514. + #ifndef __EMX__
  515.             execve (shell_path, new_argv, envp);
  516.             perror_with_name ("execve: ", shell_path);
  517. + #else
  518. +           pid = spawnve(P_NOWAIT,shell_path,
  519. +                 (const char * const *)new_argv,
  520. +                 (const char * const *)envp);
  521. +           if(pid == -1)
  522. +         perror_with_name ("spawnve: ", shell_path);
  523. + #endif      
  524.           }
  525.       }
  526. + #ifndef __EMX__
  527.         else
  528.       perror_with_name ("execve: ", program);
  529. + #endif
  530.       }
  531. ! #ifndef __EMX__
  532.     _exit (127);
  533. + #else
  534. +   return pid;
  535. + #endif
  536.   }
  537.   
  538.   /* Figure out the argument list necessary to run LINE as a command.
  539. ***************
  540. *** 1189,1200 ****
  541.        char *line, **restp;
  542.        char *shell, *ifs;
  543.   {
  544.     static char sh_chars[] = "#;\"*?[]&|<>(){}$`^";
  545. !   static char *sh_cmds[] = { "cd", "eval", "exec", "exit", "login",
  546. !                  "logout", "set", "umask", "wait", "while", "for",
  547. !                  "case", "if", ":", ".", "break", "continue",
  548. !                  "export", "read", "readonly", "shift", "times",
  549. !                  "trap", "switch", 0 };
  550.     register int i;
  551.     register char *p;
  552.     register char *ap;
  553. --- 1437,1448 ----
  554.        char *line, **restp;
  555.        char *shell, *ifs;
  556.   {
  557. + #ifndef __EMX__
  558.     static char sh_chars[] = "#;\"*?[]&|<>(){}$`^";
  559. ! #else
  560. !   static char sh_chars[] = "&|<>^()";
  561. !   int is_cmd = 1;
  562. ! #endif
  563.     register int i;
  564.     register char *p;
  565.     register char *ap;
  566. ***************
  567. *** 1213,1221 ****
  568. --- 1461,1476 ----
  569.   
  570.     /* See if it is safe to parse commands internally.  */
  571.     if (shell == 0)
  572. + #ifndef __EMX__
  573.       shell = default_shell;
  574.     else if (strcmp (shell, default_shell))
  575.       goto slow;
  576. + #else
  577. +     shell = os2_shell(0);
  578. +   else
  579. +     if (!(is_cmd = is_cmd_exe(shell)))
  580. +     goto slow;
  581. + #endif
  582.   
  583.     if (ifs != 0)
  584.       for (ap = ifs; *ap != '\0'; ++ap)
  585. ***************
  586. *** 1243,1252 ****
  587.       {
  588.         /* Inside a string, just copy any char except a closing quote
  589.            or a backslash-newline combination.  */
  590. !       if (*p == '\'')
  591.           instring = 0;
  592.         else if (*p == '\\' && p[1] == '\n')
  593.           goto swallow_escaped_newline;
  594.         else if (*p == '\n' && restp != NULL)
  595.           {
  596.             /* End of the command line.  */
  597. --- 1498,1511 ----
  598.       {
  599.         /* Inside a string, just copy any char except a closing quote
  600.            or a backslash-newline combination.  */
  601. !       if (*p == instring)
  602.           instring = 0;
  603.         else if (*p == '\\' && p[1] == '\n')
  604.           goto swallow_escaped_newline;
  605. + #ifdef __EMX__
  606. +       else if (*p == '\\') /* except if guarded by \ */
  607. +         *ap++ = *++p;
  608. + #endif
  609.         else if (*p == '\n' && restp != NULL)
  610.           {
  611.             /* End of the command line.  */
  612. ***************
  613. *** 1304,1316 ****
  614.                 p = next_token (p) - 1;
  615.             }
  616.             }
  617. !         else if (p[1] != '\0')
  618.             /* Copy and skip the following char.  */
  619.             *ap++ = *++p;
  620.           break;
  621.   
  622.         case '\'':
  623. !         instring = 1;
  624.           break;
  625.   
  626.         case '\n':
  627. --- 1563,1585 ----
  628.                 p = next_token (p) - 1;
  629.             }
  630.             }
  631. !         else if (p[1] != '\0') {
  632. ! #ifdef __EMX__
  633. !           /* for OS/2, let's keep single \ before characters and numbers
  634. !          because \ is commonly used as path name separator */
  635. !           if (isalnum(p[1]))
  636. !         *ap++ = *p;
  637. ! #endif
  638.             /* Copy and skip the following char.  */
  639.             *ap++ = *++p;
  640. +         }
  641.           break;
  642.   
  643. + #ifdef __EMX__
  644. +       case '"':
  645. + #endif
  646.         case '\'':
  647. !         instring = *p;
  648.           break;
  649.   
  650.         case '\n':
  651. ***************
  652. *** 1345,1358 ****
  653.           /* If this argument is the command name,
  654.              see if it is a built-in shell command.
  655.              If so, have the shell handle it.  */
  656. !         if (i == 1)
  657. !           {
  658. !         register int j;
  659. !         for (j = 0; sh_cmds[j] != 0; ++j)
  660. !           if (streq (sh_cmds[j], new_argv[0]))
  661.               goto slow;
  662.             }
  663. - 
  664.           /* Ignore multiple whitespace chars.  */
  665.           p = next_token (p);
  666.           /* Next iteration should examine the first nonwhite char.  */
  667. --- 1614,1627 ----
  668.           /* If this argument is the command name,
  669.              see if it is a built-in shell command.
  670.              If so, have the shell handle it.  */
  671. !         if (i == 1) {
  672. !             if(is_shell_command(new_argv[0]))
  673. !           goto slow;
  674. ! #ifdef __EMX__
  675. !             if (is_script(new_argv[0]))
  676.               goto slow;
  677. + #endif                
  678.             }
  679.           /* Ignore multiple whitespace chars.  */
  680.           p = next_token (p);
  681.           /* Next iteration should examine the first nonwhite char.  */
  682. ***************
  683. *** 1379,1388 ****
  684.   
  685.     if (i == 1)
  686.       {
  687. !       register int j;
  688. !       for (j = 0; sh_cmds[j] != 0; ++j)
  689. !     if (streq (sh_cmds[j], new_argv[0]))
  690.         goto slow;
  691.       }
  692.   
  693.     if (new_argv[0] == 0)
  694. --- 1648,1659 ----
  695.   
  696.     if (i == 1)
  697.       {
  698. !       if (is_shell_command(new_argv[0]))
  699. !     goto slow;
  700. ! #ifndef __EMX__
  701. !       if (is_script(new_argv[0]))
  702.         goto slow;
  703. + #endif
  704.       }
  705.   
  706.     if (new_argv[0] == 0)
  707. ***************
  708. *** 1408,1424 ****
  709.          argument list.  */
  710.       
  711.       unsigned int shell_len = strlen (shell);
  712.       static char minus_c[] = " -c ";
  713.       unsigned int line_len = strlen (line);
  714. !     
  715. !     char *new_line = (char *) alloca (shell_len + (sizeof (minus_c) - 1)
  716.                         + (line_len * 2) + 1);
  717. -     
  718.       ap = new_line;
  719.       bcopy (shell, ap, shell_len);
  720.       ap += shell_len;
  721. !     bcopy (minus_c, ap, sizeof (minus_c) - 1);
  722. !     ap += sizeof (minus_c) - 1;
  723.       for (p = line; *p != '\0'; ++p)
  724.         {
  725.       if (restp != NULL && *p == '\n')
  726. --- 1679,1704 ----
  727.          argument list.  */
  728.       
  729.       unsigned int shell_len = strlen (shell);
  730. + #ifndef __EMX__
  731.       static char minus_c[] = " -c ";
  732. + #define MINUS_C_SIZE sizeof(minus_c)
  733. + #else
  734. +     char *minus_c = " /c ";
  735. + #define MINUS_C_SIZE (strlen(minus_c)+1)
  736. + #endif
  737.       unsigned int line_len = strlen (line);
  738. !     char *new_line;
  739. ! #ifdef __EMX__
  740. !     if(!is_cmd)
  741. !       minus_c = " -c ";
  742. ! #endif    
  743. !     new_line = (char *) alloca (shell_len + (MINUS_C_SIZE - 1)
  744.                         + (line_len * 2) + 1);
  745.       ap = new_line;
  746.       bcopy (shell, ap, shell_len);
  747.       ap += shell_len;
  748. !     bcopy (minus_c, ap, MINUS_C_SIZE - 1);
  749. !     ap += MINUS_C_SIZE - 1;
  750.       for (p = line; *p != '\0'; ++p)
  751.         {
  752.       if (restp != NULL && *p == '\n')
  753. ***************
  754. *** 1429,1455 ****
  755.       else if (*p == '\\' && p[1] == '\n')
  756.         {
  757.           /* Eat the backslash, the newline, and following whitespace,
  758. !            replacing it all with a single space (which is escaped
  759. !            from the shell).  */
  760.           p += 2;
  761.   
  762. !         /* If there is a tab after a backslash-newline,
  763. !            remove it from the source line which will be echoed,
  764. !            since it was most likely used to line
  765.              up the continued line with the previous one.  */
  766. !         if (*p == '\t')
  767.             strcpy (p, p + 1);
  768.   
  769.           p = next_token (p);
  770.           --p;
  771.           *ap++ = '\\';
  772.           *ap++ = ' ';
  773.           continue;
  774.         }
  775.   
  776. !     if (*p == '\\' || *p == '\''
  777. !         || isspace (*p)
  778. !         || index (sh_chars, *p) != 0)
  779.         *ap++ = '\\';
  780.       *ap++ = *p;
  781.         }
  782. --- 1709,1744 ----
  783.       else if (*p == '\\' && p[1] == '\n')
  784.         {
  785.           /* Eat the backslash, the newline, and following whitespace,
  786. !            replacing it all with a single space.  */
  787.           p += 2;
  788.   
  789. !         /* If there are tabs after a backslash-newline,
  790. !            remove them from the source line which will be echoed,
  791. !            since they were most likely used to line
  792.              up the continued line with the previous one.  */
  793. !         while (*p == '\t')
  794.             strcpy (p, p + 1);
  795.   
  796.           p = next_token (p);
  797.           --p;
  798. + #ifdef __EMX__
  799. +         if (!is_cmd)
  800. + #endif
  801.           *ap++ = '\\';
  802.           *ap++ = ' ';
  803.           continue;
  804.         }
  805.   
  806. !     if (*p == '\\' ||
  807. !         *p == '\'' ||
  808. ! #ifdef __EMX__
  809. !         *p == '"' ||
  810. ! #endif
  811. !         isspace (*p) ||
  812. !         index (sh_chars, *p) != 0)
  813. ! #ifdef __EMX__
  814. !       if(!is_cmd || index(sh_chars,*p) != 0)
  815. ! #endif
  816.         *ap++ = '\\';
  817.       *ap++ = *p;
  818.         }
  819. diff -cbr orig/job.h new/job.h
  820. *** orig/job.h    Wed Mar 23 16:13:32 1994
  821. --- new/job.h    Tue Jun 07 17:39:20 1994
  822. ***************
  823. *** 46,54 ****
  824.   extern void start_waiting_jobs ();
  825.   
  826.   extern char **construct_command_argv ();
  827.   extern void child_execute_job ();
  828.   extern void exec_command ();
  829. ! 
  830.   extern unsigned int job_slots_used;
  831.   
  832.   #ifdef POSIX
  833. --- 46,58 ----
  834.   extern void start_waiting_jobs ();
  835.   
  836.   extern char **construct_command_argv ();
  837. + #ifndef __EMX__
  838.   extern void child_execute_job ();
  839.   extern void exec_command ();
  840. ! #else
  841. ! extern int child_execute_job ();
  842. ! extern int exec_command ();
  843. ! #endif
  844.   extern unsigned int job_slots_used;
  845.   
  846.   #ifdef POSIX
  847. diff -cbr orig/main.c new/main.c
  848. *** orig/main.c    Thu Apr 21 04:08:24 1994
  849. --- new/main.c    Tue Jun 07 17:39:22 1994
  850. ***************
  851. *** 396,401 ****
  852. --- 396,406 ----
  853.     PATH_VAR (current_directory);
  854.     char *directory_before_chdir;
  855.   
  856. + #ifdef __EMX__
  857. +   _response(&argc,&argv);
  858. +   _wildcard(&argc,&argv);
  859. + #endif
  860. + 
  861.     default_goal_file = 0;
  862.     reading_filename = 0;
  863.     reading_lineno_ptr = 0;
  864. ***************
  865. *** 607,616 ****
  866.        If it is a name with no slash, we can only hope that PATH did not
  867.        find it in the current directory.)  */
  868.   
  869.     if (current_directory[0] != '\0'
  870.         && argv[0] != 0 && argv[0][0] != '/' && index (argv[0], '/') != 0)
  871.       argv[0] = concat (current_directory, "/", argv[0]);
  872. ! 
  873.     (void) define_variable ("MAKE_COMMAND", 12, argv[0], o_default, 0);
  874.   
  875.     /* Append the command-line variable definitions gathered above
  876. --- 612,636 ----
  877.        If it is a name with no slash, we can only hope that PATH did not
  878.        find it in the current directory.)  */
  879.   
  880. + #ifndef __EMX__
  881.     if (current_directory[0] != '\0'
  882.         && argv[0] != 0 && argv[0][0] != '/' && index (argv[0], '/') != 0)
  883.       argv[0] = concat (current_directory, "/", argv[0]);
  884. ! #else
  885. !   if (current_directory[0] != '\0' && /* there is a cwd */
  886. !       argv[0] != 0 &&            /* there is an argv[0] */
  887. !       (argv[0][0] != '/' &&        /* and it doesn't begin with slash */
  888. !       argv[0][0] != '\\' &&        /* or a backslash */
  889. !       argv[0][1] != ':') &&        /* or start with a drive letter */
  890. !       (index (argv[0], '/') != 0 ||    /*  it does contain a slash */
  891. !       index (argv[0], '\\') != 0))    /* or a backslash */
  892. !     argv[0] = concat (current_directory, "/", argv[0]);
  893. !   {
  894. !     char *cp;
  895. !     for(cp = argv[0]; *cp != '\0'; cp++)
  896. !       *cp = (*cp == '\\') ? '/' : *cp;
  897. !   }
  898. ! #endif
  899.     (void) define_variable ("MAKE_COMMAND", 12, argv[0], o_default, 0);
  900.   
  901.     /* Append the command-line variable definitions gathered above
  902. ***************
  903. *** 694,704 ****
  904.           /* This makefile is standard input.  Since we may re-exec
  905.              and thus re-read the makefiles, we read standard input
  906.              into a temporary file and read from that.  */
  907. !         static char name[] = "/tmp/GmXXXXXX";
  908.           FILE *outfile;
  909.   
  910.           /* Make a unique filename.  */
  911. !         (void) mktemp (name);
  912.   
  913.           outfile = fopen (name, "w");
  914.           if (outfile == 0)
  915. --- 714,724 ----
  916.           /* This makefile is standard input.  Since we may re-exec
  917.              and thus re-read the makefiles, we read standard input
  918.              into a temporary file and read from that.  */
  919. !         char name[PATH_MAX];
  920.           FILE *outfile;
  921.   
  922.           /* Make a unique filename.  */
  923. !         tmpnam (name);
  924.   
  925.           outfile = fopen (name, "w");
  926.           if (outfile == 0)
  927. ***************
  928. *** 1054,1060 ****
  929. --- 1074,1084 ----
  930.         fflush (stdout);
  931.         fflush (stderr);
  932.   
  933. + #ifndef __EMX__
  934.         exec_command (argv, environ);
  935. + #else
  936. +       exit(exec_command (argv, environ));
  937. + #endif
  938.         /* NOTREACHED */
  939.       }
  940.       }
  941. ***************
  942. *** 1337,1343 ****
  943.       {
  944.         /* Print a nice usage message.  */
  945.   
  946. -       if (print_version_flag)
  947.       print_version ();
  948.   
  949.         fprintf (stderr, "Usage: %s [options] [target] ...\n", program);
  950. --- 1361,1366 ----
  951. ***************
  952. *** 1758,1769 ****
  953.         if (print_version_flag)
  954.       print_version ();
  955.   
  956.         /* Wait for children to die.  */
  957.         for (err = status != 0; job_slots_used > 0; err = 0)
  958.       reap_children (1, err);
  959. - 
  960. -       /* Remove the intermediate files.  */
  961. -       remove_intermediates (0);
  962.   
  963.         if (print_data_base_flag)
  964.       print_data_base ();
  965. --- 1781,1792 ----
  966.         if (print_version_flag)
  967.       print_version ();
  968.   
  969. +       /* Remove the intermediate files.  */
  970. +       remove_intermediates (0);
  971. + 
  972.         /* Wait for children to die.  */
  973.         for (err = status != 0; job_slots_used > 0; err = 0)
  974.       reap_children (1, err);
  975.   
  976.         if (print_data_base_flag)
  977.       print_data_base ();
  978. diff -cbr orig/make.h new/make.h
  979. *** orig/make.h    Sat May 21 22:23:48 1994
  980. --- new/make.h    Tue Jun 07 17:39:22 1994
  981. ***************
  982. *** 321,327 ****
  983. --- 321,335 ----
  984.   #define    getcwd(buf, len)    getwd (buf)
  985.   #endif
  986.   
  987. + #if defined(sgi) || defined(__EMX__)
  988.   extern char **environ;
  989. + #else
  990. + #ifndef NSIG
  991. + #define NSIG 33
  992. + #endif
  993. + extern char **_environ;
  994. + #define environ _environ
  995. + #endif
  996.   
  997.   extern char *reading_filename;
  998.   extern unsigned int *reading_lineno_ptr;
  999. diff -cbr orig/read.c new/read.c
  1000. *** orig/read.c    Tue May 03 00:35:24 1994
  1001. --- new/read.c    Tue Jun 07 21:27:34 1994
  1002. ***************
  1003. *** 699,704 ****
  1004. --- 699,709 ----
  1005.   
  1006.         /* Is this a static pattern rule: `target: %targ: %dep; ...'?  */
  1007.         p = index (p2, ':');
  1008. + #ifdef __EMX__
  1009. +       /* allow path names with drive specifications (x:) */
  1010. +       if (p != 0 && !isspace(p[1]))
  1011. +         p = 0;
  1012. + #endif
  1013.         while (p != 0 && p[-1] == '\\')
  1014.           {
  1015.             register char *q = &p[-1];
  1016. ***************
  1017. *** 1228,1233 ****
  1018. --- 1233,1242 ----
  1019.                        pattern_percent, percent);
  1020.           free (d->name);
  1021.           d->name = savestring (buffer, o - buffer);
  1022. + #ifdef __EMX__
  1023. +         if (d->name[0] != '.')
  1024. +           _fnlwr(d->name);
  1025. + #endif
  1026.             }
  1027.         }
  1028.         
  1029. ***************
  1030. *** 1431,1438 ****
  1031. --- 1440,1456 ----
  1032.       {
  1033.         if (blank)
  1034.       {
  1035. + #ifdef __EMX__
  1036. +       while (*p != '\0' && !isblank (*p))
  1037. +         if (*p == stopchar && (stopchar != ':' || isblank(p[1]) || 
  1038. +                    p[1] == 0 || p[1] == ':' || p[1] == ';'))
  1039. +           break;
  1040. +         else
  1041. +           ++p;
  1042. + #else
  1043.         while (*p != '\0' && *p != stopchar && !isblank (*p))
  1044.           ++p;
  1045. + #endif
  1046.         if (*p == '\0')
  1047.           break;
  1048.       }
  1049. ***************
  1050. *** 1734,1739 ****
  1051. --- 1752,1759 ----
  1052.         if (!backslash)
  1053.       {
  1054.         p[-1] = '\0';
  1055. +       if (p - p2 > 2)
  1056. +         p[-2] = '\0'; /* kill one of multiple backslashes */
  1057.         break;
  1058.       }
  1059.   
  1060. ***************
  1061. *** 1934,1939 ****
  1062. --- 1954,1963 ----
  1063.           {
  1064.             free (old->name);
  1065.             old->name = newname;
  1066. + #ifdef __EMX__
  1067. +           if (old->name[0] != '.')
  1068. +         _fnlwr(old->name);
  1069. + #endif
  1070.           }
  1071.       }
  1072.   
  1073. ***************
  1074. *** 2004,2009 ****
  1075. --- 2028,2037 ----
  1076.               struct nameseq *elt = (struct nameseq *) xmalloc (size);
  1077.               elt->name = savestring (gl.gl_pathv[i],
  1078.                           strlen (gl.gl_pathv[i]));
  1079. + #ifdef __EMX__
  1080. +             if (old->name[0] != '.')
  1081. +               _fnlwr(elt->name);
  1082. + #endif
  1083.               elt->next = new;
  1084.               new = elt;
  1085.             }
  1086. diff -cbr orig/variable.c new/variable.c
  1087. *** orig/variable.c    Tue Apr 05 12:09:14 1994
  1088. --- new/variable.c    Tue Jun 07 17:39:24 1994
  1089. ***************
  1090. *** 366,371 ****
  1091. --- 366,372 ----
  1092.     v = define_variable ("SHELL", 5, default_shell, o_default, 0);
  1093.     v->export = v_export;        /* Always export SHELL.  */
  1094.   
  1095. + #ifndef __EMX__
  1096.     /* Don't let SHELL come from the environment.  */
  1097.     if (*v->value == '\0' || v->origin == o_env || v->origin == o_env_override)
  1098.       {
  1099. ***************
  1100. *** 373,378 ****
  1101. --- 374,388 ----
  1102.         v->origin = o_file;
  1103.         v->value = savestring (default_shell, strlen (default_shell));
  1104.       }
  1105. + #else
  1106. +     {
  1107. +       extern char *os2_shell(int);
  1108. +       char *cp = os2_shell(0);
  1109. +       v->value = savestring (cp, strlen(cp));
  1110. +       for(cp = v->value; *cp != '\0'; cp++)
  1111. +     *cp = (*cp == '\\' ? '/' : *cp);
  1112. +     }
  1113. + #endif
  1114.   
  1115.     /* Make sure MAKEFILES gets exported if it is set.  */
  1116.     v = define_variable ("MAKEFILES", 9, "", o_default, 0);
  1117. ***************
  1118. *** 610,615 ****
  1119. --- 620,628 ----
  1120.       --end;
  1121.     p = next_token (p);
  1122.   
  1123. +   /* don't try to do this for empty names */
  1124. +   if(end < beg)
  1125. +     return 0;
  1126.     /* Expand the name, so "$(foo)bar = baz" works.  */
  1127.     name = (char *) alloca (end - beg + 1);
  1128.     bcopy (beg, name, end - beg);
  1129.